{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.107372Z",
     "start_time": "2021-03-22T05:32:53.400242Z"
    },
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/edraff/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n",
      "  after removing the cwd from sys.path.\n"
     ]
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from tqdm.autonotebook import tqdm\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.114216Z",
     "start_time": "2021-03-22T05:32:54.109474Z"
    },
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from IPython.display import set_matplotlib_formats\n",
    "set_matplotlib_formats('png', 'pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.669963Z",
     "start_time": "2021-03-22T05:32:54.116147Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.676062Z",
     "start_time": "2021-03-22T05:32:54.671481Z"
    }
   },
   "outputs": [],
   "source": [
    "torch_scalar = torch.tensor(3.14)\n",
    "torch_vector = torch.tensor([1, 2, 3, 4])\n",
    "torch_matrix = torch.tensor([[1, 2,],\n",
    "                             [3, 4,],\n",
    "                             [5, 6,], \n",
    "                             [7, 8,]])\n",
    "#You don't have to format it like I did, thats just for clarity\n",
    "torch_tensor3d = torch.tensor([\n",
    "                            [\n",
    "                            [ 1,  2,  3], \n",
    "                            [ 4,  5,  6],\n",
    "                            ],\n",
    "                            [\n",
    "                            [ 7,  8,  9], \n",
    "                            [10, 11, 12],\n",
    "                            ],\n",
    "                            [\n",
    "                            [13, 14, 15], \n",
    "                            [16, 17, 18],\n",
    "                            ],\n",
    "                            [\n",
    "                            [19, 20, 21], \n",
    "                            [22, 23, 24],\n",
    "                            ]\n",
    "                              ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.688664Z",
     "start_time": "2021-03-22T05:32:54.677220Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([])\n",
      "torch.Size([4])\n",
      "torch.Size([4, 2])\n",
      "torch.Size([4, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "print(torch_scalar.shape)\n",
    "print(torch_vector.shape)\n",
    "print(torch_matrix.shape)\n",
    "print(torch_tensor3d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.694456Z",
     "start_time": "2021-03-22T05:32:54.690164Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.71304914 0.75111365 0.88005547 0.30691052]\n",
      " [0.00798065 0.39193293 0.43515506 0.72272704]\n",
      " [0.92679196 0.54127469 0.89011186 0.02201878]\n",
      " [0.42746772 0.65896634 0.9028333  0.84611058]]\n"
     ]
    }
   ],
   "source": [
    "x_np = np.random.random((4,4))\n",
    "print(x_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.701736Z",
     "start_time": "2021-03-22T05:32:54.697048Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.7130, 0.7511, 0.8801, 0.3069],\n",
      "        [0.0080, 0.3919, 0.4352, 0.7227],\n",
      "        [0.9268, 0.5413, 0.8901, 0.0220],\n",
      "        [0.4275, 0.6590, 0.9028, 0.8461]], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "x_pt = torch.tensor(x_np)\n",
    "print(x_pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.708524Z",
     "start_time": "2021-03-22T05:32:54.703648Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64 torch.float64\n"
     ]
    }
   ],
   "source": [
    "print(x_np.dtype, x_pt.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.715713Z",
     "start_time": "2021-03-22T05:32:54.710165Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float32 torch.float32\n"
     ]
    }
   ],
   "source": [
    "#Lets force them to be 32-bit floats\n",
    "x_np = np.asarray(x_np, dtype=np.float32)\n",
    "x_pt = torch.tensor(x_np, dtype=torch.float32)\n",
    "print(x_np.dtype, x_pt.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.722368Z",
     "start_time": "2021-03-22T05:32:54.717373Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True  True  True False]\n",
      " [False False False  True]\n",
      " [ True  True  True False]\n",
      " [False  True  True  True]]\n",
      "bool\n"
     ]
    }
   ],
   "source": [
    "b_np = (x_np > 0.5)\n",
    "print(b_np)\n",
    "print(b_np.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.729593Z",
     "start_time": "2021-03-22T05:32:54.724132Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ True,  True,  True, False],\n",
      "        [False, False, False,  True],\n",
      "        [ True,  True,  True, False],\n",
      "        [False,  True,  True,  True]])\n",
      "torch.bool\n"
     ]
    }
   ],
   "source": [
    "b_pt = (x_pt > 0.5)\n",
    "print(b_pt)\n",
    "print(b_pt.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.737835Z",
     "start_time": "2021-03-22T05:32:54.730952Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.4244995"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(x_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.743037Z",
     "start_time": "2021-03-22T05:32:54.739198Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(9.4245)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.sum(x_pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.747879Z",
     "start_time": "2021-03-22T05:32:54.744383Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.7130491 , 0.00798065, 0.92679197, 0.4274677 ],\n",
       "       [0.75111365, 0.39193293, 0.54127467, 0.65896636],\n",
       "       [0.8800555 , 0.43515506, 0.89011186, 0.9028333 ],\n",
       "       [0.3069105 , 0.72272706, 0.02201878, 0.8461106 ]], dtype=float32)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(x_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.755058Z",
     "start_time": "2021-03-22T05:32:54.749723Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.7130, 0.0080, 0.9268, 0.4275],\n",
       "        [0.7511, 0.3919, 0.5413, 0.6590],\n",
       "        [0.8801, 0.4352, 0.8901, 0.9028],\n",
       "        [0.3069, 0.7227, 0.0220, 0.8461]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.transpose(x_pt, 0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:54.763796Z",
     "start_time": "2021-03-22T05:32:54.756945Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 2, 4])\n"
     ]
    }
   ],
   "source": [
    "print(torch.transpose(torch_tensor3d, 0, 2).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:59.532902Z",
     "start_time": "2021-03-22T05:32:54.765163Z"
    }
   },
   "outputs": [],
   "source": [
    "import timeit\n",
    "x = torch.rand(2**11, 2**11)\n",
    "time_cpu = timeit.timeit(\"x@x\", globals=globals(), number=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:32:59.578188Z",
     "start_time": "2021-03-22T05:32:59.539627Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is CUDA available? : True\n"
     ]
    }
   ],
   "source": [
    "print(\"Is CUDA available? :\", torch.cuda.is_available())\n",
    "device = torch.device(\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:01.740576Z",
     "start_time": "2021-03-22T05:32:59.580308Z"
    }
   },
   "outputs": [],
   "source": [
    "x = x.to(device)\n",
    "time_gpu = timeit.timeit(\"x@x\", globals=globals(), number=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:01.957208Z",
     "start_time": "2021-03-22T05:33:01.750393Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[tensor(1), tensor(2)]\n",
      "[tensor(1, device='cuda:0'), tensor(2, device='cuda:0')]\n"
     ]
    }
   ],
   "source": [
    "def moveTo(obj, device):\n",
    "    \"\"\"\n",
    "    obj: the python object to move to a device, or to move its contents to a device\n",
    "    device: the compute device to move objects to\n",
    "    \"\"\"\n",
    "    if isinstance(obj, list):\n",
    "        return [moveTo(x, device) for x in obj]\n",
    "    elif isinstance(obj, tuple):\n",
    "        return tuple(moveTo(list(obj), device))\n",
    "    elif isinstance(obj, set):\n",
    "        return set(moveTo(list(obj), device))\n",
    "    elif isinstance(obj, dict):\n",
    "        to_ret = dict()\n",
    "        for key, value in obj.items():\n",
    "            to_ret[moveTo(key, device)] = moveTo(value, device)\n",
    "        return to_ret\n",
    "    elif hasattr(obj, \"to\"):\n",
    "        return obj.to(device)\n",
    "    else:\n",
    "        return obj\n",
    "    \n",
    "some_tensors = [torch.tensor(1), torch.tensor(2)]\n",
    "print(some_tensors)\n",
    "print(moveTo(some_tensors, device))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.498610Z",
     "start_time": "2021-03-22T05:33:01.960934Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f(x):\n",
    "    return torch.pow((x-2.0), 2)\n",
    "\n",
    "x_axis_vals = np.linspace(-7,9,100) \n",
    "y_axis_vals = f(torch.tensor(x_axis_vals)).numpy()\n",
    "\n",
    "sns.lineplot(x=x_axis_vals, y=y_axis_vals, label='$f(x)=(x-2)^2$')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.866511Z",
     "start_time": "2021-03-22T05:33:02.501436Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def fP(x): #Defining the derivative of f(x) manually\n",
    "    return 2*x-4\n",
    "\n",
    "y_axis_vals_p = fP(torch.tensor(x_axis_vals)).numpy()\n",
    "\n",
    "#First, lets draw a black line at 0, so that we can easily tell if something is positive or negative\n",
    "sns.lineplot(x=x_axis_vals, y=[0.0]*len(x_axis_vals), label=\"0\", color='black')\n",
    "sns.lineplot(x=x_axis_vals, y=y_axis_vals, label='$f(x) = (x-2)^2$')\n",
    "sns.lineplot(x=x_axis_vals, y=y_axis_vals_p, label=\"$f'(x)=2 x - 4$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.872628Z",
     "start_time": "2021-03-22T05:33:02.868281Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([-3.5], requires_grad=True)\n",
    "print(x.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.879284Z",
     "start_time": "2021-03-22T05:33:02.874597Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([30.2500], grad_fn=<PowBackward0>)\n"
     ]
    }
   ],
   "source": [
    "value = f(x)\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.887619Z",
     "start_time": "2021-03-22T05:33:02.881506Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-11.])\n"
     ]
    }
   ],
   "source": [
    "value.backward()\n",
    "print(x.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.906233Z",
     "start_time": "2021-03-22T05:33:02.888975Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([2.0000])\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([-3.5], requires_grad=True)\n",
    "\n",
    "x_cur = x.clone()\n",
    "x_prev = x_cur*100 #Make the initial \"previous\" solution larger\n",
    "epsilon = 1e-5\n",
    "eta = 0.1\n",
    "\n",
    "while torch.linalg.norm(x_cur-x_prev) > epsilon:\n",
    "    x_prev = x_cur.clone() #We need to make a clone here so that x_prev and x_cur don't point to the same object\n",
    "    \n",
    "    #Compute our function, gradient, and update\n",
    "    value = f(x)\n",
    "    value.backward()\n",
    "    x.data -= eta * x.grad\n",
    "    x.grad.zero_() #We need to zero out the old gradient, as py-torch will not do that for us\n",
    "    \n",
    "    #What are we currently now?\n",
    "    x_cur = x.data\n",
    "    \n",
    "print(x_cur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.911171Z",
     "start_time": "2021-03-22T05:33:02.908110Z"
    }
   },
   "outputs": [],
   "source": [
    "x_param = torch.nn.Parameter(torch.tensor([-3.5]), requires_grad=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.916541Z",
     "start_time": "2021-03-22T05:33:02.913522Z"
    }
   },
   "outputs": [],
   "source": [
    "optimizer = torch.optim.SGD([x_param], lr=eta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:02.933325Z",
     "start_time": "2021-03-22T05:33:02.918744Z"
    },
    "tags": [
     "remove_output"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([2.0000])\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(60):\n",
    "    optimizer.zero_grad() #x.grad.zero_()\n",
    "    loss_incurred  = f(x_param)\n",
    "    loss_incurred.backward()\n",
    "    optimizer.step() #x.data -= eta * x.grad\n",
    "print(x_param.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:18.679235Z",
     "start_time": "2021-03-22T05:33:02.939654Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(70000, 784)\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import Dataset\n",
    "from sklearn.datasets import fetch_openml\n",
    "\n",
    "# Load data from https://www.openml.org/d/554\n",
    "X, y = fetch_openml('mnist_784', version=1, return_X_y=True)\n",
    "print(X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:18.684096Z",
     "start_time": "2021-03-22T05:33:18.680539Z"
    }
   },
   "outputs": [],
   "source": [
    "class SimpleDataset(Dataset):\n",
    "        \n",
    "    def __init__(self, X, y):\n",
    "        super(SimpleDataset, self).__init__()\n",
    "        self.X = X\n",
    "        self.y = y\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        #This \"work\" could have gone in the constructor, but you should get into \n",
    "        inputs = torch.tensor(self.X[index,:], dtype=torch.float32)\n",
    "        targets = torch.tensor(int(self.y[index]), dtype=torch.int64)\n",
    "        return inputs, targets \n",
    "\n",
    "    def __len__(self):\n",
    "        return self.X.shape[0]\n",
    "#Now we can make a PyTorch dataset \n",
    "dataset = SimpleDataset(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:18.698359Z",
     "start_time": "2021-03-22T05:33:18.685197Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length:  70000\n",
      "Features:  torch.Size([784])\n",
      "Label of index 0:  tensor(5)\n"
     ]
    }
   ],
   "source": [
    "print(\"Length: \", len(dataset))\n",
    "example, label = dataset[0]\n",
    "print(\"Features: \", example.shape) #Will return 784\n",
    "print(\"Label of index 0: \", label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:18.934961Z",
     "start_time": "2021-03-22T05:33:18.700260Z"
    },
    "max_h": 0.3,
    "max_w": 0.9
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f3d87846150>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/pdf": "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\n",
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(example.reshape((28,28)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-22T05:33:18.943218Z",
     "start_time": "2021-03-22T05:33:18.936102Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56000 examples for training and 14000 for testing\n"
     ]
    }
   ],
   "source": [
    "train_size = int(len(dataset)*0.8)\n",
    "test_size = len(dataset)-train_size\n",
    "\n",
    "train_dataset, test_dataset = torch.utils.data.random_split(dataset, (train_size, test_size))\n",
    "print(\"{} examples for training and {} for testing\".format(len(train_dataset), len(test_dataset)))"
   ]
  }
 ],
 "metadata": {
  "author": "Why PyTorch?",
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": false,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "latex_metadata": {
   "title": "The Mechanics of Learning"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
